package com.common.app.utls

import android.graphics.Color
import android.util.Log

/**
 *
 * 作者：sosou
 *
 * 版本：1.0
 *
 * 创建日期：2025/10/1/
 *
 * 描述：
 *
 * 修订历史：
 *
 */
object ColorUtils {

    val defColor = "#BB33FF"

    /**
     * 将颜色值转换为16进制字符串表示形式（包含透明度）
     *
     * @param color Int类型的颜色值
     * @return 16进制颜色字符串，格式为 #AARRGGBB
     */
    fun colorIntToRgb(color: Int): IntArray {
        val red = (color and 0xff0000) shr 16
        val green = (color and 0x00ff00) shr 8
        val blue = (color and 0x0000ff)
//        Color.rgb(red, green, blue)
        return try {
            intArrayOf(
                red, // Red
                green, // Green
                blue  // Blue
            )
        } catch (e: Exception) {
            intArrayOf(0, 0, 0)
        }
    }

    /**
     * 将颜色值转换为16进制字符串表示形式（包含透明度）
     *
     * @param color Int类型的颜色值
     * @return 16进制颜色字符串，格式为 #AARRGGBB
     */
    fun colorToHexStringWithAlpha(color: Int): String {
        // 提取ARGB分量
        val alpha = Color.alpha(color)
        val red = Color.red(color)
        val green = Color.green(color)
        val blue = Color.blue(color)

        // 转换为16进制字符串，并确保每个分量都是两位数
        return String.format("#%02X%02X%02X%02X", alpha, red, green, blue)
    }

    /**
     * 将16进制颜色字符串转换为RGB值
     *
     * @param hexColor 16进制颜色字符串，支持格式：#RGB、#RRGGBB、#ARGB、#AARRGGBB
     * @return RGB值的IntArray，格式为 [red, green, blue]，如果解析失败返回 [0, 0, 0]
     */
    fun hexColorToRgb(hexColor: String): IntArray {
        return try {
            // 移除#号并转换为大写
            val cleanHex = hexColor.replace("#", "").uppercase()

            when (cleanHex.length) {
                3 -> {
                    // #RGB 格式，如 #F0A -> #FF00AA
                    val r = cleanHex[0].toString().repeat(2)
                    val g = cleanHex[1].toString().repeat(2)
                    val b = cleanHex[2].toString().repeat(2)
                    intArrayOf(
                        r.toInt(16),
                        g.toInt(16),
                        b.toInt(16)
                    )
                }
                4 -> {
                    // #ARGB 格式，如 #AF0A -> #AAFF00AA，忽略Alpha通道
                    val r = cleanHex[1].toString().repeat(2)
                    val g = cleanHex[2].toString().repeat(2)
                    val b = cleanHex[3].toString().repeat(2)
                    intArrayOf(
                        r.toInt(16),
                        g.toInt(16),
                        b.toInt(16)
                    )
                }
                6 -> {
                    // #RRGGBB 格式，如 #99FF99
                    intArrayOf(
                        cleanHex.substring(0, 2).toInt(16), // Red
                        cleanHex.substring(2, 4).toInt(16), // Green
                        cleanHex.substring(4, 6).toInt(16)  // Blue
                    )
                }
                8 -> {
                    // #AARRGGBB 格式，如 #FF99FF99，忽略Alpha通道
                    intArrayOf(
                        cleanHex.substring(2, 4).toInt(16), // Red
                        cleanHex.substring(4, 6).toInt(16), // Green
                        cleanHex.substring(6, 8).toInt(16)  // Blue
                    )
                }
                else -> {
                    Log.e("ColorSelection", "不支持的颜色格式: $hexColor")
                    intArrayOf(0, 0, 0)
                }
            }
        } catch (e: Exception) {
            Log.e("ColorSelection", "颜色解析失败: $hexColor", e)
            intArrayOf(0, 0, 0)
        }
    }

    /**
     * 将16进制颜色字符串转换为单个RGB值（用于显示）
     *
     * @param hexColor 16进制颜色字符串
     * @return 格式化的RGB字符串，如 "R:153, G:255, B:153"
     */
    fun hexColorToRgbString(hexColor: String): String {
        val rgb = hexColorToRgb(hexColor)
        return "R:${rgb[0]}, G:${rgb[1]}, B:${rgb[2]}"
    }

    /**
     * 将16进制颜色字符串转换为Int颜色值（用于setCardBackgroundColor等方法）
     *
     * @param hexColor 16进制颜色字符串，支持格式：#RGB、#RRGGBB、#ARGB、#AARRGGBB
     * @return Int类型的颜色值，如果解析失败返回透明色(0)
     */
    fun hexColorToInt(hexColor: String): Int {
        return try {
            // 移除#号并转换为大写
            val cleanHex = hexColor.replace("#", "").uppercase()

            when (cleanHex.length) {
                3 -> {
                    // #RGB 格式，如 #F0A -> #FF00AA，默认Alpha为FF
                    val r = cleanHex[0].toString().repeat(2)
                    val g = cleanHex[1].toString().repeat(2)
                    val b = cleanHex[2].toString().repeat(2)
                    Color.parseColor("#FF$r$g$b")
                }
                4 -> {
                    // #ARGB 格式，如 #AF0A -> #AAFF00AA
                    val a = cleanHex[0].toString().repeat(2)
                    val r = cleanHex[1].toString().repeat(2)
                    val g = cleanHex[2].toString().repeat(2)
                    val b = cleanHex[3].toString().repeat(2)
                    Color.parseColor("#$a$r$g$b")
                }
                6 -> {
                    // #RRGGBB 格式，如 #99FF99，默认Alpha为FF
                    Color.parseColor("#FF$cleanHex")
                }
                8 -> {
                    // #AARRGGBB 格式，如 #FF99FF99
                    Color.parseColor("#$cleanHex")
                }
                else -> {
                    Log.e("ColorSelection", "不支持的颜色格式: $hexColor")
                    0 // 透明色
                }
            }
        } catch (e: Exception) {
            Log.e("ColorSelection", "颜色解析失败: $hexColor", e)
            0 // 透明色
        }
    }

    /**
     * 将16进制颜色字符串转换为Int颜色值（简化版本，使用Android原生方法）
     *
     * @param hexColor 16进制颜色字符串，格式：#RRGGBB 或 #AARRGGBB
     * @return Int类型的颜色值
     */
    fun hexColorToIntSimple(hexColor: String): Int {
        return try {
            Color.parseColor(hexColor)
        } catch (e: Exception) {
            Log.e("ColorSelection", "颜色解析失败: $hexColor", e)
            Color.TRANSPARENT
        }
    }
}